////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2017-2018 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// THIS IS AUTO-GENERATED CODE.  PLEASE DO NOT EDIT (File bug reports against tools).
///
/// Auto-generated by: ParameterParser V1.1.4
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  aecflash.h
/// @brief Auto-generated Chromatix parameter file
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef AECFLASH_H
#define AECFLASH_H

#include "parametermodule.h"
#include "parameterfilesymboltable.h"
#include "parametertypes.h"
#include "globalelements.h"
#include "aecglobalelements.h"

#define AECFLASH_NAMESPACE_BEGIN namespace aecFlash {
#define AECFLASH_NAMESPACE_END }

AECFLASH_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// LEDMeasurementType
///
/// Description:   Flash measurement configuration. These parameters apply to both flash tuning and flash calibration
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct LEDMeasurementType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// frameErrAllowance
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   For either flash calibration or flash tuning: Frame to frame error allowance when computing average r/g
    ///                and b/g ratios
    /// Range:         [0.005,0.03]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT frameErrAllowance;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// numOfFrames
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   For either flash calibration or flash tuning: How many frames to average the average r/g b/g ratios
    /// Range:         [3,5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 numOfFrames;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// maxNumOfFrames
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   For either flash calibration or flash tuning: Maximum number of frames to try averaging r/g and b/g ratio
    ///                when stats are not consistent (cf. error allowance) before stopping measurement
    /// Range:         [6,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 maxNumOfFrames;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// maxNumOfExtraAttempts
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   For either flash calibration or flash tuning: When a measurement fails we can allow some extra attempts.
    ///                This parameter controls how many extra attempts in total are allowed
    /// Range:         [2,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 maxNumOfExtraAttempts;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// LEDRatioOkRangeType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct LEDRatioOkRangeType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// RGRatioOKRange
    ///
    /// Tuning Level:  often_tune
    /// Description:   Pass range of the r/g deviation percentage from golden device to device under test, for current
    ///                calibration index. Calibration will fail if outside of this range.
    /// Range:         [0.7,1.3]
    /// Comments:       Base Type Tuning Definition
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::StartEndType RGRatioOKRange;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// BGRatioOKRange
    ///
    /// Tuning Level:  often_tune
    /// Description:   Pass range of the b/g deviation percentage from golden device to device under test, for current
    ///                calibration index. Calibration will fail if outside of this range.
    /// Range:         [0.7,1.3]
    /// Comments:       Base Type Tuning Definition
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::StartEndType BGRatioOKRange;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// LEDMixCalibEntryType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct LEDMixCalibEntryType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// LEDPowerIndex
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Power index of LED point to calibrate
    /// Range:         [0,5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 LEDPowerIndex;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// LEDMixIndex
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Mix index of LED point to calibrate
    /// Range:         [0,15]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 LEDMixIndex;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// LEDMixCalibType
///
/// Description:   LED calibration controls. AEC LED calibration is tightly linked to AEC LED CCT table tuning
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct LEDMixCalibType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// numOfCalibration
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Number of points to calibrate
    /// Range:         [0,12]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                 numOfCalibration;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableCornerSampleScreen
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Enable screening calibration point to screen out obvious issues
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL                  enableCornerSampleScreen;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// calibEntries - Array
    /// Min Length:    1
    /// Max Length:    12
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                calibEntriesCount;
    UINT32                calibEntriesID;
    LEDMixCalibEntryType* calibEntries;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// statsRatioOKRange - Array
    /// Min Length:    1
    /// Max Length:    12
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                statsRatioOKRangeCount;
    UINT32                statsRatioOKRangeID;
    LEDRatioOkRangeType*  statsRatioOKRange;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// fixedExpIndex - Array
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Manual exposure index for given
    /// Range:         [0,500]
    /// Min Length:    1
    /// Max Length:    12
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                fixedExpIndexCount;
    UINT32                fixedExpIndexID;
    FLOAT*                fixedExpIndex;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// LEDMixType
///
/// Description:   Tuning of LED parameters for both single and dual LED
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct LEDMixType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// LED1Setting
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Use LED tuning tool to populate LED tuning table. Power level for LED1 in mA. Max value depends on
    ///                hardware design and driver
    /// Range:         [0,1000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 LED1Setting;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// LED2Setting
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Use LED tuning tool to populate LED tuning table. Power level for LED2 in mA. Max value depends on
    ///                hardware design and driver
    /// Range:         [0,1000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 LED2Setting;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// RGRatio
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Use LED tuning tool to populate LED tuning table. Red over green ratio for current mix
    /// Range:         [0.0,1.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT RGRatio;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// BGRatio
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Use LED tuning tool to populate LED tuning table. Blue over green ratio for current mix
    /// Range:         [0.0,1.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT BGRatio;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// flux
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Use LED tuning tool to populate LED tuning table. Influence of flash on scene in reference to entry in
    ///                power level mix 0
    /// Range:         [0.0,7.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT flux;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// LEDMatchTableType
///
/// Description:   Tuning of LEDs for flash exposure conistency as well as color matching consistency for dual LED solutions
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct LEDMatchTableType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableDualLED
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Use LED tuning tool to populate this parameter. If project is using single LED set to false, if using
    ///                dual LED set to true.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL               enableDualLED;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// dualLEDIntersectSlope
    ///
    /// Tuning Level:  never_tune
    /// Description:   For dual LED: intersection slope between measured AWB gray point and LED data in the r/g vs. b/g color
    ///                domain
    /// Range:         [0.0,5.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT              dualLEDIntersectSlope;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// LEDPowerSize
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Use LED tuning tool to populate this parameter. How many power levels are tuned.
    /// Range:         [2,6]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32              LEDPowerSize;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// LEDMixSize
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Use LED tuning tool to populate this parameter. How many mixes are there for each power level
    /// Range:         [1,16]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32              LEDMixSize;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CCTTables - Array
    ///
    /// Description:   Tuning of LED parameters for both single and dual LED
    /// Min Length:    1
    /// Max Length:    96
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32             CCTTablesCount;
    UINT32             CCTTablesID;
    LEDMixType*        CCTTables;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CCTTableCalibration
    ///
    /// Description:   LED calibration controls. AEC LED calibration is tightly linked to AEC LED CCT table tuning
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    LEDMixCalibType    CCTTableCalibration;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// LEDMeasConfig
    ///
    /// Description:   Flash measurement configuration. These parameters apply to both flash tuning and flash calibration
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    LEDMeasurementType LEDMeasConfig;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// FlashExtensionType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct FlashExtensionType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// flashLuxTrigger
    ///
    /// Tuning Level:  often_tune
    /// Description:   Lux hysteresis thresholds to trigger flash.
    /// Range:         [300,500]
    /// Comments:       Base Type Tuning Definition
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::StartEndType      flashLuxTrigger;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// flashFDRequestDelayLuxTrigger
    ///
    /// Tuning Level:  often_tune
    /// Description:   Lux hysteresis thresholds to request additional time for face detection to run
    /// Range:         [300,500]
    /// Comments:       Base Type Tuning Definition
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::StartEndType      flashFDRequestDelayLuxTrigger;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// LEDTable
    ///
    /// Description:   Tuning of LEDs for flash exposure conistency as well as color matching consistency for dual LED solutions
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    LEDMatchTableType LEDTable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableForceAFInLEDOnMode
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Set to true to always run LED AF when LED is in force ON mode.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL              enableForceAFInLEDOnMode;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// FlashArbitrationType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct FlashArbitrationType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// expTableIDPreFlash
    ///
    /// Tuning Level:  often_tune
    /// Description:   Index of exposure table to use during preflash convergence
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::ExposureTableIDType expTableIDPreFlash;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// expTableIDMainFlash
    ///
    /// Tuning Level:  often_tune
    /// Description:   Index of exposure table to use for flash snapshot
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::ExposureTableIDType expTableIDMainFlash;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// expTableIDFlashMeasurement
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Index of exposure table to use during chromatix flash tuning
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::ExposureTableIDType expTableIDFlashMeasurement;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// TorchConvType
///
/// Description:   Torch convergence algorithm when the LED is in torch mode.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct TorchConvType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableTorchConvergence
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Enable torch convergence feature
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL              enableTorchConvergence;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// tolMultUnitStepSize
    ///
    /// Tuning Level:  often_tune
    /// Description:   Exposure index tolerance is tolMultUnitStepSize * unitStepSize; exposure index range within which AEC
    ///                will not adjust
    /// Range:         [1,5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32             tolMultUnitStepSize;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// frameSkipMethod
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Specifies which type of frame skip is desired: SmoothNoSkip for smooth convergence, SkipOne if there are
    ///                synchronization concerns, SkipSystemLatency if speed is preferred to smoothness
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::ConvFrameSkipType frameSkipMethod;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// aggressiveness
    ///
    /// Tuning Level:  often_tune
    /// Description:   Controls convergence speed; 0.0 is slowest and 1.0 is fastest
    /// Range:         [0.0,1.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT             aggressiveness;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// startupAggressiveness
    ///
    /// Tuning Level:  often_tune
    /// Description:   How many frames minimum should torch convergence run
    /// Range:         [0,5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT             startupAggressiveness;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ADRCConvSpeed
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Convergence speed for short and long exposures. Smaller value yields slower convergence.
    /// Range:         [0.0,0.5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT             ADRCConvSpeed;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// PreFlashConvergenceType
///
/// Description:   Flash convergence tuning for preflash sequence
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct PreFlashConvergenceType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// frameSkipMethod
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Specifies which type of frame skip is desired: SmoothNoSkip for smooth convergence, SkipOne if there are
    ///                synchronization concerns, SkipSystemLatency if speed is preferred to smoothness
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::ConvFrameSkipType frameSkipMethod;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// aggressiveness
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   The larger this value the faster the convergence
    /// Range:         [0.0,1.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT             aggressiveness;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// settledFrameCountThres
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Number of additional frames to wait before declaring settled and computing flash snapshot parameters. Can
    ///                be reduced if sensor sync is reliable
    /// Range:         [0,3]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32             settledFrameCountThres;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// FlashConvergenceType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct FlashConvergenceType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// preflashConv
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Tuning for convergence during preflash phase of flash snapshot
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    PreFlashConvergenceType preflashConv;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// flashMeasurementConv
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Tuning for convergence during flash chromatix tuning procedure
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::RapidConvType           flashMeasurementConv;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// torchConv
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Tuning for convergence during torch mode
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    TorchConvType           torchConv;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// AECFaceDetectionFlashType
///
/// Description:   This feature runs face detection during preflash sequence and then exposes the snapshot image using face
///                detection ROI. It can also be tuned to extend the preflash sequence and give more time for face detection
///                to run.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct AECFaceDetectionFlashType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableFDFlash
    ///
    /// Tuning Level:  often_tune
    /// Description:   Enable face detection ROI metering for flash snapshot
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL         enableFDFlash;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ledFaceWeight
    ///
    /// Tuning Level:  often_tune
    /// Description:   Weight range assigned to face depending on face size (small face will use start weight large face will
    ///                sue end weight). Leverages dominant face AEC
    /// Range:         [0.1,0.5]
    /// Comments:       Base Type Tuning Definition
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::StartEndType ledFaceWeight;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ledFaceSize
    ///
    /// Tuning Level:  often_tune
    /// Description:   Face size pct range that controls metering weight. Leverages dominant face AEC
    /// Range:         [0.05,0.5]
    /// Comments:       Base Type Tuning Definition
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::StartEndType ledFaceSize;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FDFlashFrameCount
    ///
    /// Tuning Level:  often_tune
    /// Description:   Threshold on the maximum number of frames the algorithm will wait for face detection
    /// Range:         [0,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32        FDFlashFrameCount;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FDFlashLumaTarget
    ///
    /// Tuning Level:  often_tune
    /// Description:   Luma target for face ROIs
    /// Range:         [40,70]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT        FDFlashLumaTarget;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// faceSizeExpEffect
    ///
    /// Tuning Level:  often_tune
    /// Description:   Range of face size within which the effect of flash face detection phases in and out. Large face should
    ///                make full use of FD metering
    /// Range:         [0.005,0.4]
    /// Comments:       Base Type Tuning Definition
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::StartEndType faceSizeExpEffect;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// statsUpdateDelayTimeEnter
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Specify the delay in seconds to declare Face ROI officially comes into effect (for detection stability)
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT        statsUpdateDelayTimeEnter;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// statsUpdateDelayTimeExit
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Specify the delay in seconds to declare Face ROI officially exits (for detection stability)
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT        statsUpdateDelayTimeExit;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// FlashStatsPreprocessingType
///
/// Description:   Preflash metering defines which regions are influenced by flash. It also speeds up preflash convergence
///                sequence.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct FlashStatsPreprocessingType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thresBrightLevelDiff
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   During preflash convergence: Y region is still too bright if larger than thresBrightLevel +
    ///                thresBrightLevelDiff. The lower this value the more likely convergence will adjust after preflash turns
    ///                on
    /// Range:         [5,50]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 thresBrightLevelDiff;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thresBrightLevel
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Mark Y region as bright when above this threshold
    /// Range:         [180,210]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 thresBrightLevel;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thresBrightSatDiff
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   During preflash convergence: Y region is saturated if sat percentage is larger than thresBrightSat +
    ///                thresBrightSatDiff. The lower this value the more likely convergence will adjust after preflash turns on
    /// Range:         [0.03,0.15]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT thresBrightSatDiff;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// thresBrightSat
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Mark Y region as bright when above this threshold
    /// Range:         [0.15,0.3]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT thresBrightSat;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// minLuma
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Preflash convergence will stop if luma drops below this threshold
    /// Range:         [8,25]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 minLuma;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// minLumaAdj
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Minimum adjustment during preflash convergence. The larger this value the more precise convergence but
    ///                also the longer it takes to converge
    /// Range:         [0.5,1.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT minLumaAdj;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SmartFlashType
///
/// Description:   Smart flash uses a bias table computed by comparing stats before and after preflash to better expose
///                scenes that have both foreground and background features
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct SmartFlashType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableSmartFlashEst
    ///
    /// Tuning Level:  often_tune
    /// Description:   Enable metering scene using flash influence bias table
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL         enableSmartFlashEst;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// smartFlashEstStrength
    ///
    /// Tuning Level:  often_tune
    /// Description:   Strength of smart flash feature
    /// Default Value: 1.0
    /// Range:         [0.0,2.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT        smartFlashEstStrength;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// minOffStats
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Off stats value will be set to this value as to make the on_stats/off_stats ratio robust to noise
    /// Range:         [2,5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32        minOffStats;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// kFloorPct
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Percentile threshold to compress flash influence. The larger this value the more emphasis on small
    ///                reflective objects
    /// Range:         [0.0,0.95]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT        kFloorPct;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// satPreventStrength
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Strength of saturation prevention feature
    /// Range:         [0.0,1.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT        satPreventStrength;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableSpeckleHandling
    ///
    /// Tuning Level:  often_tune
    /// Description:   This feature allows saturation to happen if it is shaped like a speckle
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL         enableSpeckleHandling;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// speckleSatPctRange
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Saturation pct range within which we will decrease influence of region. Above this range influence of
    ///                region is decreased to minimum. Lower range to make speckle detection kick in more often.
    /// Range:         [0.01,1.0]
    /// Comments:       Base Type Tuning Definition
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::StartEndType speckleSatPctRange;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// FlashLumaTargetType
///
/// Description:   Tune lux-based luma target specifically for flash
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct FlashLumaTargetType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableFlashTarget
    ///
    /// Tuning Level:  often_tune
    /// Description:   Enable separate luma target for flash snapshot capture
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL              enableFlashTarget;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// flashTarget
    ///
    /// Description:   Luma target tuning structure, which is shared between normal and flash use case.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::LuxLumaTargetType flashTarget;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// flashInfluenceTargetInterpolation
    ///
    /// Tuning Level:  rarely_tune
    /// Description:   Interpolation between normal target and flash target is done by measuring the influence of flash: No
    ///                influence (min: 1.0) should use normal target whereas strong influence (about 5.0 and above) should use
    ///                flash target.
    /// Range:         [1.0,7.0]
    /// Comments:       Base Type Tuning Definition
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    aecglobalelements::StartEndType      flashInfluenceTargetInterpolation;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// FlashMeteringType
///
/// Description:   Metering for flash photography
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct FlashMeteringType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// flashLumaTarget
    ///
    /// Description:   Tune lux-based luma target specifically for flash
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FlashLumaTargetType         flashLumaTarget;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// smartFlash
    ///
    /// Description:   Smart flash uses a bias table computed by comparing stats before and after preflash to better expose
    ///                scenes that have both foreground and background features
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SmartFlashType              smartFlash;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// statsPreprocessing
    ///
    /// Description:   Preflash metering defines which regions are influenced by flash. It also speeds up preflash convergence
    ///                sequence.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FlashStatsPreprocessingType statsPreprocessing;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FDFlash
    ///
    /// Description:   This feature runs face detection during preflash sequence and then exposes the snapshot image using face
    ///                detection ROI. It can also be tuned to extend the preflash sequence and give more time for face detection
    ///                to run.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    AECFaceDetectionFlashType   FDFlash;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// AECFlashType
/// Comments:       Flash Tuning Definition
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct AECFlashType
{
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Binary file symbol table entry ID
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 SymbolTableID;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// module_version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct module_versionStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;
        INT32 major_revision;
        INT32 minor_revision;
        INT32 incr_revision;
    } module_version;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// flashMtr
    ///
    /// Description:   Metering for flash photography
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FlashMeteringType    flashMtr;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// flashConv
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FlashConvergenceType flashConv;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// flashArb
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FlashArbitrationType flashArb;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// flashExt
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FlashExtensionType   flashExt;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// AECFlashTypeClass
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class AECFlashTypeClass : public ParameterModule, public AECFlashType
{
public:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static const UINT16 MAJOR = 1;
    static const UINT16 MINOR = 0;
    static const UINT32 PATCH = 0;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Default Constructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    AECFlashTypeClass(
        const CHAR* name);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Constructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    AECFlashTypeClass(
        const CHAR* name,
        UINT32 modeId,
        UINT16 mode,
        UINT16 subMode,
        UINT32 group);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Destructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ~AECFlashTypeClass();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetName
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static const CHAR* GetName(
        const CHAR* type);


    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load LEDMeasurementType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadLEDMeasurementType(
        ParameterFileSymbolTableEntry* entry,
        LEDMeasurementType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load LEDRatioOkRangeType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadLEDRatioOkRangeType(
        ParameterFileSymbolTableEntry* entry,
        LEDRatioOkRangeType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load LEDMixCalibEntryType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadLEDMixCalibEntryType(
        ParameterFileSymbolTableEntry* entry,
        LEDMixCalibEntryType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load LEDMixCalibType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadLEDMixCalibType(
        ParameterFileSymbolTableEntry* entry,
        LEDMixCalibType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load LEDMixType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadLEDMixType(
        ParameterFileSymbolTableEntry* entry,
        LEDMixType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load LEDMatchTableType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadLEDMatchTableType(
        ParameterFileSymbolTableEntry* entry,
        LEDMatchTableType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load FlashExtensionType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadFlashExtensionType(
        ParameterFileSymbolTableEntry* entry,
        FlashExtensionType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load FlashArbitrationType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadFlashArbitrationType(
        ParameterFileSymbolTableEntry* entry,
        FlashArbitrationType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load TorchConvType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadTorchConvType(
        ParameterFileSymbolTableEntry* entry,
        TorchConvType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load PreFlashConvergenceType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadPreFlashConvergenceType(
        ParameterFileSymbolTableEntry* entry,
        PreFlashConvergenceType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load FlashConvergenceType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadFlashConvergenceType(
        ParameterFileSymbolTableEntry* entry,
        FlashConvergenceType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load AECFaceDetectionFlashType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadAECFaceDetectionFlashType(
        ParameterFileSymbolTableEntry* entry,
        AECFaceDetectionFlashType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load FlashStatsPreprocessingType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadFlashStatsPreprocessingType(
        ParameterFileSymbolTableEntry* entry,
        FlashStatsPreprocessingType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load SmartFlashType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadSmartFlashType(
        ParameterFileSymbolTableEntry* entry,
        SmartFlashType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load FlashLumaTargetType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadFlashLumaTargetType(
        ParameterFileSymbolTableEntry* entry,
        FlashLumaTargetType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load FlashMeteringType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadFlashMeteringType(
        ParameterFileSymbolTableEntry* entry,
        FlashMeteringType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load AECFlashType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadAECFlashType(
        ParameterFileSymbolTableEntry* entry,
        AECFlashType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load module_versionStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL Loadmodule_versionStruct(
        ParameterFileSymbolTableEntry* entry,
        AECFlashType::module_versionStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload LEDMixCalibType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadLEDMixCalibType(
        LEDMixCalibType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload LEDMatchTableType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadLEDMatchTableType(
        LEDMatchTableType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload FlashExtensionType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadFlashExtensionType(
        FlashExtensionType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload FlashLumaTargetType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadFlashLumaTargetType(
        FlashLumaTargetType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload FlashMeteringType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadFlashMeteringType(
        FlashMeteringType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload AECFlashType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadAECFlashType(
        AECFlashType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Parse symbol table entry, and return a new object
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ParameterModule* Parse(
        ParameterSetManager* manager,
        ParameterFileSymbolTableEntry* entry) const;

}; // End class AECFlashTypeClass

AECFLASH_NAMESPACE_END
#endif // AECFLASH_H

